home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / src / linux-headers-2.6.28-15 / include / scsi / scsi_device.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-24  |  16.3 KB  |  463 lines
  1. #ifndef _SCSI_SCSI_DEVICE_H
  2. #define _SCSI_SCSI_DEVICE_H
  3.  
  4. #include <linux/device.h>
  5. #include <linux/list.h>
  6. #include <linux/spinlock.h>
  7. #include <linux/workqueue.h>
  8. #include <linux/blkdev.h>
  9. #include <scsi/scsi.h>
  10. #include <asm/atomic.h>
  11.  
  12. struct request_queue;
  13. struct scsi_cmnd;
  14. struct scsi_lun;
  15. struct scsi_sense_hdr;
  16.  
  17. struct scsi_mode_data {
  18.     __u32    length;
  19.     __u16    block_descriptor_length;
  20.     __u8    medium_type;
  21.     __u8    device_specific;
  22.     __u8    header_length;
  23.     __u8    longlba:1;
  24. };
  25.  
  26. /*
  27.  * sdev state: If you alter this, you also need to alter scsi_sysfs.c
  28.  * (for the ascii descriptions) and the state model enforcer:
  29.  * scsi_lib:scsi_device_set_state().
  30.  */
  31. enum scsi_device_state {
  32.     SDEV_CREATED = 1,    /* device created but not added to sysfs
  33.                  * Only internal commands allowed (for inq) */
  34.     SDEV_RUNNING,        /* device properly configured
  35.                  * All commands allowed */
  36.     SDEV_CANCEL,        /* beginning to delete device
  37.                  * Only error handler commands allowed */
  38.     SDEV_DEL,        /* device deleted 
  39.                  * no commands allowed */
  40.     SDEV_QUIESCE,        /* Device quiescent.  No block commands
  41.                  * will be accepted, only specials (which
  42.                  * originate in the mid-layer) */
  43.     SDEV_OFFLINE,        /* Device offlined (by error handling or
  44.                  * user request */
  45.     SDEV_BLOCK,        /* Device blocked by scsi lld.  No
  46.                  * scsi commands from user or midlayer
  47.                  * should be issued to the scsi
  48.                  * lld. */
  49.     SDEV_CREATED_BLOCK,    /* same as above but for created devices */
  50. };
  51.  
  52. enum scsi_device_event {
  53.     SDEV_EVT_MEDIA_CHANGE    = 1,    /* media has changed */
  54.  
  55.     SDEV_EVT_LAST        = SDEV_EVT_MEDIA_CHANGE,
  56.     SDEV_EVT_MAXBITS    = SDEV_EVT_LAST + 1
  57. };
  58.  
  59. struct scsi_event {
  60.     enum scsi_device_event    evt_type;
  61.     struct list_head    node;
  62.  
  63.     /* put union of data structures, for non-simple event types,
  64.      * here
  65.      */
  66. };
  67.  
  68. struct scsi_device {
  69.     struct Scsi_Host *host;
  70.     struct request_queue *request_queue;
  71.  
  72.     /* the next two are protected by the host->host_lock */
  73.     struct list_head    siblings;   /* list of all devices on this host */
  74.     struct list_head    same_target_siblings; /* just the devices sharing same target id */
  75.  
  76.     /* this is now protected by the request_queue->queue_lock */
  77.     unsigned int device_busy;    /* commands actually active on
  78.                      * low-level. protected by queue_lock. */
  79.     spinlock_t list_lock;
  80.     struct list_head cmd_list;    /* queue of in use SCSI Command structures */
  81.     struct list_head starved_entry;
  82.     struct scsi_cmnd *current_cmnd;    /* currently active command */
  83.     unsigned short queue_depth;    /* How deep of a queue we want */
  84.     unsigned short last_queue_full_depth; /* These two are used by */
  85.     unsigned short last_queue_full_count; /* scsi_track_queue_full() */
  86.     unsigned long last_queue_full_time;/* don't let QUEUE_FULLs on the same
  87.                        jiffie count on our counter, they
  88.                        could all be from the same event. */
  89.  
  90.     unsigned int id, lun, channel;
  91.  
  92.     unsigned int manufacturer;    /* Manufacturer of device, for using 
  93.                      * vendor-specific cmd's */
  94.     unsigned sector_size;    /* size in bytes */
  95.  
  96.     void *hostdata;        /* available to low-level driver */
  97.     char type;
  98.     char scsi_level;
  99.     char inq_periph_qual;    /* PQ from INQUIRY data */    
  100.     unsigned char inquiry_len;    /* valid bytes in 'inquiry' */
  101.     unsigned char * inquiry;    /* INQUIRY response data */
  102.     const char * vendor;        /* [back_compat] point into 'inquiry' ... */
  103.     const char * model;        /* ... after scan; point to static string */
  104.     const char * rev;        /* ... "nullnullnullnull" before scan */
  105.     unsigned char current_tag;    /* current tag */
  106.     struct scsi_target      *sdev_target;   /* used only for single_lun */
  107.  
  108.     unsigned int    sdev_bflags; /* black/white flags as also found in
  109.                  * scsi_devinfo.[hc]. For now used only to
  110.                  * pass settings from slave_alloc to scsi
  111.                  * core. */
  112.     unsigned writeable:1;
  113.     unsigned removable:1;
  114.     unsigned changed:1;    /* Data invalid due to media change */
  115.     unsigned busy:1;    /* Used to prevent races */
  116.     unsigned lockable:1;    /* Able to prevent media removal */
  117.     unsigned locked:1;      /* Media removal disabled */
  118.     unsigned borken:1;    /* Tell the Seagate driver to be 
  119.                  * painfully slow on this device */
  120.     unsigned disconnect:1;    /* can disconnect */
  121.     unsigned soft_reset:1;    /* Uses soft reset option */
  122.     unsigned sdtr:1;    /* Device supports SDTR messages */
  123.     unsigned wdtr:1;    /* Device supports WDTR messages */
  124.     unsigned ppr:1;        /* Device supports PPR messages */
  125.     unsigned tagged_supported:1;    /* Supports SCSI-II tagged queuing */
  126.     unsigned simple_tags:1;    /* simple queue tag messages are enabled */
  127.     unsigned ordered_tags:1;/* ordered queue tag messages are enabled */
  128.     unsigned was_reset:1;    /* There was a bus reset on the bus for 
  129.                  * this device */
  130.     unsigned expecting_cc_ua:1; /* Expecting a CHECK_CONDITION/UNIT_ATTN
  131.                      * because we did a bus reset. */
  132.     unsigned use_10_for_rw:1; /* first try 10-byte read / write */
  133.     unsigned use_10_for_ms:1; /* first try 10-byte mode sense/select */
  134.     unsigned skip_ms_page_8:1;    /* do not use MODE SENSE page 0x08 */
  135.     unsigned skip_ms_page_3f:1;    /* do not use MODE SENSE page 0x3f */
  136.     unsigned use_192_bytes_for_3f:1; /* ask for 192 bytes from page 0x3f */
  137.     unsigned no_start_on_add:1;    /* do not issue start on add */
  138.     unsigned allow_restart:1; /* issue START_UNIT in error handler */
  139.     unsigned manage_start_stop:1;    /* Let HLD (sd) manage start/stop */
  140.     unsigned start_stop_pwr_cond:1;    /* Set power cond. in START_STOP_UNIT */
  141.     unsigned no_uld_attach:1; /* disable connecting to upper level drivers */
  142.     unsigned select_no_atn:1;
  143.     unsigned fix_capacity:1;    /* READ_CAPACITY is too high by 1 */
  144.     unsigned guess_capacity:1;    /* READ_CAPACITY might be too high by 1 */
  145.     unsigned retry_hwerror:1;    /* Retry HARDWARE_ERROR */
  146.     unsigned last_sector_bug:1;    /* do not use multisector accesses on
  147.                        SD_LAST_BUGGY_SECTORS */
  148.  
  149.     DECLARE_BITMAP(supported_events, SDEV_EVT_MAXBITS); /* supported events */
  150.     struct list_head event_list;    /* asserted events */
  151.     struct work_struct event_work;
  152.  
  153.     unsigned int device_blocked;    /* Device returned QUEUE_FULL. */
  154.  
  155.     unsigned int max_device_blocked; /* what device_blocked counts down from  */
  156. #define SCSI_DEFAULT_DEVICE_BLOCKED    3
  157.  
  158.     atomic_t iorequest_cnt;
  159.     atomic_t iodone_cnt;
  160.     atomic_t ioerr_cnt;
  161.  
  162.     int timeout;
  163.  
  164.     struct device        sdev_gendev,
  165.                 sdev_dev;
  166.  
  167.     struct execute_work    ew; /* used to get process context on put */
  168.  
  169.     struct scsi_dh_data    *scsi_dh_data;
  170.     enum scsi_device_state sdev_state;
  171.     unsigned long        sdev_data[0];
  172. } __attribute__((aligned(sizeof(unsigned long))));
  173.  
  174. struct scsi_dh_devlist {
  175.     char *vendor;
  176.     char *model;
  177. };
  178.  
  179. struct scsi_device_handler {
  180.     /* Used by the infrastructure */
  181.     struct list_head list; /* list of scsi_device_handlers */
  182.  
  183.     /* Filled by the hardware handler */
  184.     struct module *module;
  185.     const char *name;
  186.     const struct scsi_dh_devlist *devlist;
  187.     int (*check_sense)(struct scsi_device *, struct scsi_sense_hdr *);
  188.     int (*attach)(struct scsi_device *);
  189.     void (*detach)(struct scsi_device *);
  190.     int (*activate)(struct scsi_device *);
  191.     int (*prep_fn)(struct scsi_device *, struct request *);
  192. };
  193.  
  194. struct scsi_dh_data {
  195.     struct scsi_device_handler *scsi_dh;
  196.     char buf[0];
  197. };
  198.  
  199. #define    to_scsi_device(d)    \
  200.     container_of(d, struct scsi_device, sdev_gendev)
  201. #define    class_to_sdev(d)    \
  202.     container_of(d, struct scsi_device, sdev_dev)
  203. #define transport_class_to_sdev(class_dev) \
  204.     to_scsi_device(class_dev->parent)
  205.  
  206. #define sdev_printk(prefix, sdev, fmt, a...)    \
  207.     dev_printk(prefix, &(sdev)->sdev_gendev, fmt, ##a)
  208.  
  209. #define scmd_printk(prefix, scmd, fmt, a...)                \
  210.         (scmd)->request->rq_disk ?                    \
  211.     sdev_printk(prefix, (scmd)->device, "[%s] " fmt,        \
  212.             (scmd)->request->rq_disk->disk_name, ##a) :        \
  213.     sdev_printk(prefix, (scmd)->device, fmt, ##a)
  214.  
  215. enum scsi_target_state {
  216.     STARGET_CREATED = 1,
  217.     STARGET_RUNNING,
  218.     STARGET_DEL,
  219. };
  220.  
  221. /*
  222.  * scsi_target: representation of a scsi target, for now, this is only
  223.  * used for single_lun devices. If no one has active IO to the target,
  224.  * starget_sdev_user is NULL, else it points to the active sdev.
  225.  */
  226. struct scsi_target {
  227.     struct scsi_device    *starget_sdev_user;
  228.     struct list_head    siblings;
  229.     struct list_head    devices;
  230.     struct device        dev;
  231.     unsigned int        reap_ref; /* protected by the host lock */
  232.     unsigned int        channel;
  233.     unsigned int        id; /* target id ... replace
  234.                      * scsi_device.id eventually */
  235.     unsigned int        create:1; /* signal that it needs to be added */
  236.     unsigned int        single_lun:1;    /* Indicates we should only
  237.                          * allow I/O to one of the luns
  238.                          * for the device at a time. */
  239.     unsigned int        pdt_1f_for_no_lun;    /* PDT = 0x1f */
  240.                         /* means no lun present */
  241.     /* commands actually active on LLD. protected by host lock. */
  242.     unsigned int        target_busy;
  243.     /*
  244.      * LLDs should set this in the slave_alloc host template callout.
  245.      * If set to zero then there is not limit.
  246.      */
  247.     unsigned int        can_queue;
  248.     unsigned int        target_blocked;
  249.     unsigned int        max_target_blocked;
  250. #define SCSI_DEFAULT_TARGET_BLOCKED    3
  251.  
  252.     char            scsi_level;
  253.     struct execute_work    ew;
  254.     enum scsi_target_state    state;
  255.     void             *hostdata; /* available to low-level driver */
  256.     unsigned long        starget_data[0]; /* for the transport */
  257.     /* starget_data must be the last element!!!! */
  258. } __attribute__((aligned(sizeof(unsigned long))));
  259.  
  260. #define to_scsi_target(d)    container_of(d, struct scsi_target, dev)
  261. static inline struct scsi_target *scsi_target(struct scsi_device *sdev)
  262. {
  263.     return to_scsi_target(sdev->sdev_gendev.parent);
  264. }
  265. #define transport_class_to_starget(class_dev) \
  266.     to_scsi_target(class_dev->parent)
  267.  
  268. #define starget_printk(prefix, starget, fmt, a...)    \
  269.     dev_printk(prefix, &(starget)->dev, fmt, ##a)
  270.  
  271. extern struct scsi_device *__scsi_add_device(struct Scsi_Host *,
  272.         uint, uint, uint, void *hostdata);
  273. extern int scsi_add_device(struct Scsi_Host *host, uint channel,
  274.                uint target, uint lun);
  275. extern int scsi_register_device_handler(struct scsi_device_handler *scsi_dh);
  276. extern void scsi_remove_device(struct scsi_device *);
  277. extern int scsi_unregister_device_handler(struct scsi_device_handler *scsi_dh);
  278.  
  279. extern int scsi_device_get(struct scsi_device *);
  280. extern void scsi_device_put(struct scsi_device *);
  281. extern struct scsi_device *scsi_device_lookup(struct Scsi_Host *,
  282.                           uint, uint, uint);
  283. extern struct scsi_device *__scsi_device_lookup(struct Scsi_Host *,
  284.                         uint, uint, uint);
  285. extern struct scsi_device *scsi_device_lookup_by_target(struct scsi_target *,
  286.                             uint);
  287. extern struct scsi_device *__scsi_device_lookup_by_target(struct scsi_target *,
  288.                               uint);
  289. extern void starget_for_each_device(struct scsi_target *, void *,
  290.              void (*fn)(struct scsi_device *, void *));
  291. extern void __starget_for_each_device(struct scsi_target *, void *,
  292.                       void (*fn)(struct scsi_device *,
  293.                          void *));
  294.  
  295. /* only exposed to implement shost_for_each_device */
  296. extern struct scsi_device *__scsi_iterate_devices(struct Scsi_Host *,
  297.                           struct scsi_device *);
  298.  
  299. /**
  300.  * shost_for_each_device - iterate over all devices of a host
  301.  * @sdev: the &struct scsi_device to use as a cursor
  302.  * @shost: the &struct scsi_host to iterate over
  303.  *
  304.  * Iterator that returns each device attached to @shost.  This loop
  305.  * takes a reference on each device and releases it at the end.  If
  306.  * you break out of the loop, you must call scsi_device_put(sdev).
  307.  */
  308. #define shost_for_each_device(sdev, shost) \
  309.     for ((sdev) = __scsi_iterate_devices((shost), NULL); \
  310.          (sdev); \
  311.          (sdev) = __scsi_iterate_devices((shost), (sdev)))
  312.  
  313. /**
  314.  * __shost_for_each_device - iterate over all devices of a host (UNLOCKED)
  315.  * @sdev: the &struct scsi_device to use as a cursor
  316.  * @shost: the &struct scsi_host to iterate over
  317.  *
  318.  * Iterator that returns each device attached to @shost.  It does _not_
  319.  * take a reference on the scsi_device, so the whole loop must be
  320.  * protected by shost->host_lock.
  321.  *
  322.  * Note: The only reason to use this is because you need to access the
  323.  * device list in interrupt context.  Otherwise you really want to use
  324.  * shost_for_each_device instead.
  325.  */
  326. #define __shost_for_each_device(sdev, shost) \
  327.     list_for_each_entry((sdev), &((shost)->__devices), siblings)
  328.  
  329. extern void scsi_adjust_queue_depth(struct scsi_device *, int, int);
  330. extern int scsi_track_queue_full(struct scsi_device *, int);
  331.  
  332. extern int scsi_set_medium_removal(struct scsi_device *, char);
  333.  
  334. extern int scsi_mode_sense(struct scsi_device *sdev, int dbd, int modepage,
  335.                unsigned char *buffer, int len, int timeout,
  336.                int retries, struct scsi_mode_data *data,
  337.                struct scsi_sense_hdr *);
  338. extern int scsi_mode_select(struct scsi_device *sdev, int pf, int sp,
  339.                 int modepage, unsigned char *buffer, int len,
  340.                 int timeout, int retries,
  341.                 struct scsi_mode_data *data,
  342.                 struct scsi_sense_hdr *);
  343. extern int scsi_test_unit_ready(struct scsi_device *sdev, int timeout,
  344.                 int retries, struct scsi_sense_hdr *sshdr);
  345. extern int scsi_device_set_state(struct scsi_device *sdev,
  346.                  enum scsi_device_state state);
  347. extern struct scsi_event *sdev_evt_alloc(enum scsi_device_event evt_type,
  348.                       gfp_t gfpflags);
  349. extern void sdev_evt_send(struct scsi_device *sdev, struct scsi_event *evt);
  350. extern void sdev_evt_send_simple(struct scsi_device *sdev,
  351.               enum scsi_device_event evt_type, gfp_t gfpflags);
  352. extern int scsi_device_quiesce(struct scsi_device *sdev);
  353. extern void scsi_device_resume(struct scsi_device *sdev);
  354. extern void scsi_target_quiesce(struct scsi_target *);
  355. extern void scsi_target_resume(struct scsi_target *);
  356. extern void scsi_scan_target(struct device *parent, unsigned int channel,
  357.                  unsigned int id, unsigned int lun, int rescan);
  358. extern void scsi_target_reap(struct scsi_target *);
  359. extern void scsi_target_block(struct device *);
  360. extern void scsi_target_unblock(struct device *);
  361. extern void scsi_remove_target(struct device *);
  362. extern void int_to_scsilun(unsigned int, struct scsi_lun *);
  363. extern int scsilun_to_int(struct scsi_lun *);
  364. extern const char *scsi_device_state_name(enum scsi_device_state);
  365. extern int scsi_is_sdev_device(const struct device *);
  366. extern int scsi_is_target_device(const struct device *);
  367. extern int scsi_execute(struct scsi_device *sdev, const unsigned char *cmd,
  368.             int data_direction, void *buffer, unsigned bufflen,
  369.             unsigned char *sense, int timeout, int retries,
  370.             int flag);
  371. extern int scsi_execute_req(struct scsi_device *sdev, const unsigned char *cmd,
  372.                 int data_direction, void *buffer, unsigned bufflen,
  373.                 struct scsi_sense_hdr *, int timeout, int retries);
  374. extern int scsi_execute_async(struct scsi_device *sdev,
  375.                   const unsigned char *cmd, int cmd_len, int data_direction,
  376.                   void *buffer, unsigned bufflen, int use_sg,
  377.                   int timeout, int retries, void *privdata,
  378.                   void (*done)(void *, char *, int, int),
  379.                   gfp_t gfp);
  380.  
  381. static inline int __must_check scsi_device_reprobe(struct scsi_device *sdev)
  382. {
  383.     return device_reprobe(&sdev->sdev_gendev);
  384. }
  385.  
  386. static inline unsigned int sdev_channel(struct scsi_device *sdev)
  387. {
  388.     return sdev->channel;
  389. }
  390.  
  391. static inline unsigned int sdev_id(struct scsi_device *sdev)
  392. {
  393.     return sdev->id;
  394. }
  395.  
  396. #define scmd_id(scmd) sdev_id((scmd)->device)
  397. #define scmd_channel(scmd) sdev_channel((scmd)->device)
  398.  
  399. /*
  400.  * checks for positions of the SCSI state machine
  401.  */
  402. static inline int scsi_device_online(struct scsi_device *sdev)
  403. {
  404.     return sdev->sdev_state != SDEV_OFFLINE;
  405. }
  406. static inline int scsi_device_blocked(struct scsi_device *sdev)
  407. {
  408.     return sdev->sdev_state == SDEV_BLOCK ||
  409.         sdev->sdev_state == SDEV_CREATED_BLOCK;
  410. }
  411. static inline int scsi_device_created(struct scsi_device *sdev)
  412. {
  413.     return sdev->sdev_state == SDEV_CREATED ||
  414.         sdev->sdev_state == SDEV_CREATED_BLOCK;
  415. }
  416.  
  417. /* accessor functions for the SCSI parameters */
  418. static inline int scsi_device_sync(struct scsi_device *sdev)
  419. {
  420.     return sdev->sdtr;
  421. }
  422. static inline int scsi_device_wide(struct scsi_device *sdev)
  423. {
  424.     return sdev->wdtr;
  425. }
  426. static inline int scsi_device_dt(struct scsi_device *sdev)
  427. {
  428.     return sdev->ppr;
  429. }
  430. static inline int scsi_device_dt_only(struct scsi_device *sdev)
  431. {
  432.     if (sdev->inquiry_len < 57)
  433.         return 0;
  434.     return (sdev->inquiry[56] & 0x0c) == 0x04;
  435. }
  436. static inline int scsi_device_ius(struct scsi_device *sdev)
  437. {
  438.     if (sdev->inquiry_len < 57)
  439.         return 0;
  440.     return sdev->inquiry[56] & 0x01;
  441. }
  442. static inline int scsi_device_qas(struct scsi_device *sdev)
  443. {
  444.     if (sdev->inquiry_len < 57)
  445.         return 0;
  446.     return sdev->inquiry[56] & 0x02;
  447. }
  448. static inline int scsi_device_enclosure(struct scsi_device *sdev)
  449. {
  450.     return sdev->inquiry[6] & (1<<6);
  451. }
  452.  
  453. static inline int scsi_device_protection(struct scsi_device *sdev)
  454. {
  455.     return sdev->scsi_level > SCSI_2 && sdev->inquiry[5] & (1<<0);
  456. }
  457.  
  458. #define MODULE_ALIAS_SCSI_DEVICE(type) \
  459.     MODULE_ALIAS("scsi:t-" __stringify(type) "*")
  460. #define SCSI_DEVICE_MODALIAS_FMT "scsi:t-0x%02x"
  461.  
  462. #endif /* _SCSI_SCSI_DEVICE_H */
  463.